home *** CD-ROM | disk | FTP | other *** search
/ Aminet 44 / Aminet 44 (2001)(GTI - Schatztruhe)[!][Aug 2001].iso / Aminet / comm / misc / Camedia.lha / Camedia / Camedia.c < prev    next >
C/C++ Source or Header  |  2001-06-07  |  38KB  |  1,605 lines
  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <time.h>
  5.  
  6. #include <dos/dos.h>
  7. #include <exec/exec.h>
  8. #include <devices/serial.h>
  9.  
  10. //#include <clib/exec_protos.h>    // TetiSoft
  11. //#include <clib/dos_protos.h>    // TetiSoft
  12. #include <proto/exec.h>        // TetiSoft
  13. #include <proto/dos.h>        // TetiSoft
  14.  
  15. #include <clib/alib_protos.h>
  16.  
  17. //#include <pragma/dos_lib.h>    // TetiSoft
  18. //#include <pragma/exec_lib.h>    // TetiSoft
  19.  
  20. #include "Camedia.h"
  21.  
  22. __inline void read_L1(L1 *, char* error_msg);    // TetiSoft: Moved from Camedia.h
  23. __inline void send_L1(L1, char* error_msg);    // TetiSoft: Moved from Camedia.h
  24. __inline void send_L2(L2, char* error_msg);    // TetiSoft: Moved from Camedia.h
  25. __inline L2 checksum(L1 *, L1 *);        // TetiSoft: Moved from Camedia.h
  26.  
  27. struct MsgPort  *SerialMP=NULL;
  28. struct MsgPort  *TimerMP=NULL;
  29. struct IOExtSer *SerialIO=NULL;
  30. struct timerequest *TimerIO=NULL;
  31.  
  32. ULONG WaitMask;
  33. int get_preview=0;
  34. int first_Packet=1;
  35. char error_msg_buffer[256];
  36.  
  37. void clean(int entrypoint) {
  38.     switch(entrypoint) {
  39.         case 100:
  40.         case 101:
  41.             if (TimerIO) {
  42.             CloseDevice((struct IORequest *) TimerIO);
  43.         }
  44.         case 102:
  45.             if (SerialIO) {
  46.                 CloseDevice((struct IORequest *) SerialIO);
  47.             }
  48.         case 103:
  49.             if (TimerIO) {
  50.                 DeleteExtIO((struct IORequest *) TimerIO);
  51.                 TimerIO=NULL;
  52.             }
  53.         case 104:
  54.             if (SerialIO) {
  55.                 DeleteExtIO((struct IORequest *) SerialIO);
  56.                 SerialIO=NULL;
  57.             }
  58.         case 105:
  59.             if (TimerMP) {
  60.                 DeletePort(TimerMP);
  61.                 TimerMP=NULL;
  62.             }
  63.         case 106:
  64.             if (SerialMP) {
  65.                 DeletePort(SerialMP);
  66.                 SerialMP=NULL;
  67.             }
  68.     };
  69. }
  70.  
  71.  
  72. void bootstrap(char *serial_device, int unit, char* error_msg) {
  73.     SerialMP=CreatePort(0,0);
  74.     if (!SerialMP) {
  75.         strcpy(error_msg, "Couldn't do CreateMsgPort() for SerialMP");
  76.         return;
  77.     }
  78.     
  79.     TimerMP=CreatePort(0,0);
  80.     if (!SerialMP) {
  81.         clean(106);
  82.         strcpy(error_msg, "Couldn't do CreateMsgPort() for TimerMP");
  83.         return;
  84.     }
  85.     
  86.     if (!(SerialIO = (struct IOExtSer *) CreateExtIO(SerialMP, sizeof(struct IOExtSer)))) {
  87.         clean(105);
  88.         strcpy(error_msg, "Couldn't do CreateExtIO() for SerialIO");
  89.         return;
  90.     }
  91.     
  92.     if (!(TimerIO = (struct timerequest *) CreateExtIO(TimerMP, sizeof(struct timerequest)))) {
  93.         clean(104);
  94.         strcpy(error_msg, "Couldn't do CreateExtIO() for TimerIO");
  95.         return;
  96.     }
  97.     
  98.     if (OpenDevice(serial_device, (ULONG) unit, (struct IORequest *) SerialIO, 0)) {
  99.         sprintf(error_msg_buffer, "Error, couldn't open %s, unit %d", serial_device, unit);
  100.         clean(103);
  101.         strcpy(error_msg, error_msg_buffer);
  102.         return;
  103.     }
  104.     
  105.     SerialIO->io_RBufLen=2060;
  106.     SerialIO->io_SerFlags &=SERF_XDISABLED | SERF_RAD_BOOGIE;
  107.     SerialIO->IOSer.io_Command = SDCMD_SETPARAMS;
  108.     if (DoIO((struct IORequest *)SerialIO)) {
  109.         sprintf(error_msg_buffer, "Error, couldn't set the read buffer from %s, unit %d to 2060 bytes", serial_device, unit);
  110.         clean(103);
  111.         strcpy(error_msg, error_msg_buffer);
  112.         return;
  113.     }
  114.     
  115.     
  116.     if (OpenDevice(TIMERNAME, UNIT_VBLANK, (struct IORequest *) TimerIO, 0L)) {
  117.         clean(102);
  118.         strcpy(error_msg, "Error, couldn't open timer device");
  119.         return;
  120.     }
  121.  
  122.     WaitMask=SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_F| 1L<<SerialMP->mp_SigBit | 1L<<TimerMP->mp_SigBit;
  123. }
  124.  
  125. void SetSerialSpeed(enum Camera_Speed cam_speed, char* error_msg ) {
  126.     long computer_speed;
  127.     
  128.     switch(cam_speed) {
  129.         case CAMERA_SPEED_9600:
  130.             computer_speed=9600;
  131.             break;
  132.             
  133.         case CAMERA_SPEED_19200:
  134.         case CAMERA_SPEED_INIT:
  135.             computer_speed=19200;
  136.             break;
  137.             
  138.         case CAMERA_SPEED_38400:
  139.             computer_speed=38400;
  140.             break;
  141.             
  142.         case CAMERA_SPEED_57600:
  143.             computer_speed=57600;
  144.             break;
  145.             
  146.         case CAMERA_SPEED_115200:
  147.             computer_speed=115200;
  148.             break;
  149.         
  150.         case CAMERA_SPEED_230400:    // Added by TetiSoft
  151.             computer_speed=230400;    // Added by TetiSoft
  152.             break;            // Added by TetiSoft
  153.         
  154.         default:
  155.             strcpy(error_msg, "Unknown Camera speed");
  156.             return;
  157.     }
  158.     
  159.     SerialIO->io_Baud=computer_speed;
  160.     SerialIO->IOSer.io_Command = SDCMD_SETPARAMS;
  161.     if (DoIO((struct IORequest *)SerialIO)) strcpy(error_msg, "Error in SetSerialSpeed");
  162. }
  163.  
  164. void init(enum Camera_Speed cs, char* error_msg ) {
  165.     L1 r;
  166.     int retry=0;
  167.  
  168.     while (retry<MAX_RETRIES) {
  169.  
  170.         SetSerialSpeed(CAMERA_SPEED_INIT, error_msg);
  171.         if (*error_msg!=0) goto init_catch;
  172.         // check speed
  173.         send_L1(Computer_Initialization_Byte, error_msg);
  174.         if (*error_msg!=0) goto init_catch;
  175.         
  176.         read_L1(&r, error_msg);
  177.         if (*error_msg!=0) goto init_catch;
  178.         if (r==Camera_Signature) {
  179.             Set_Comm_Speed(cs, error_msg);
  180.             if (*error_msg!=0) goto init_catch;
  181.             return;
  182.         }                
  183.     
  184.     init_catch:
  185.         printf("got error in init: %s\n", error_msg);
  186.         retry++;
  187.         error_msg[0]='\0';    // TetiSoft: We must clear this before trying again...
  188.         Delay(200);
  189.     }
  190.     strcpy(error_msg, "Couldn't do init");
  191. }
  192.  
  193.  
  194. void send(L1 *cb, long length, char* error_msg) {
  195.     ULONG result;
  196.     
  197.     SerialIO->IOSer.io_Length  = length;
  198.     SerialIO->IOSer.io_Data    = (APTR) cb;
  199.     SerialIO->IOSer.io_Command = CMD_WRITE;
  200.     
  201.     TimerIO->tr_node.io_Command = TR_ADDREQUEST;
  202.     TimerIO->tr_time.tv_secs=TIMEOUT;
  203.     TimerIO->tr_time.tv_micro=0;
  204.     
  205. #ifdef comm_debug
  206.     printf("Will send %d bytes:\n", length);
  207.     print_bytes(cb, length);
  208. #endif
  209.     
  210.     SendIO((struct IORequest *) TimerIO);
  211.     SendIO((struct IORequest *) SerialIO);
  212.     while (1) {
  213.         result=Wait(WaitMask);
  214.         if (CheckIO((struct IORequest *) SerialIO) ) {
  215.             WaitIO((struct IORequest *) SerialIO);
  216.             if (!CheckIO((struct IORequest *) TimerIO) ) AbortIO((struct IORequest *) TimerIO);
  217.             WaitIO((struct IORequest *) TimerIO);
  218. #ifdef comm_debug
  219.             printf("Send was ok\n\n");
  220. #endif
  221.             return;
  222.         }
  223.         if (CheckIO((struct IORequest *) TimerIO) ) {
  224.             // Timeout
  225.             WaitIO((struct IORequest *) TimerIO);
  226.             if (!CheckIO((struct IORequest *) SerialIO) )AbortIO((struct IORequest *) SerialIO);
  227.             WaitIO((struct IORequest *) SerialIO);
  228.             strcpy(error_msg, "timeout error");
  229.             return;
  230.         }
  231.         if (result & (SIGBREAKF_CTRL_C|SIGBREAKF_CTRL_F)) {
  232.             if (!CheckIO((struct IORequest *) SerialIO) )AbortIO((struct IORequest *) SerialIO);
  233.             WaitIO((struct IORequest *) SerialIO);
  234.             if (!CheckIO((struct IORequest *) TimerIO) ) AbortIO((struct IORequest *) TimerIO);
  235.             WaitIO((struct IORequest *) TimerIO);
  236.             strcpy(error_msg, "User sent CTRL_C or F");
  237.             return;
  238.         }
  239.     }
  240. }
  241.  
  242. __inline void send_L1(L1 b, char* error_msg) {
  243.     send(&b,1, error_msg);
  244. }
  245.  
  246. __inline void send_L2(L2 s, char* error_msg) {
  247.     L2 n;
  248.     
  249.     n=SetL2(s);
  250.     send((L1 *) &n, 2, error_msg);
  251. }
  252.  
  253. void read(L1 *cb, long max_size, char* error_msg) {
  254.     ULONG result;
  255.  
  256. #ifdef comm_debug
  257.     printf("Would like to receive %d bytes\n", max_size);
  258. #endif
  259.  
  260.     SerialIO->IOSer.io_Length  = max_size;
  261.     SerialIO->IOSer.io_Data    = (APTR) cb;
  262.     SerialIO->IOSer.io_Command = CMD_READ;
  263.  
  264.     TimerIO->tr_node.io_Command = TR_ADDREQUEST;
  265.     TimerIO->tr_time.tv_secs=TIMEOUT;
  266.     TimerIO->tr_time.tv_micro=0;
  267.  
  268.     SendIO((struct IORequest *) TimerIO);
  269.     SendIO((struct IORequest *) SerialIO);
  270.     
  271.     while (1) {
  272.         result=Wait(WaitMask);
  273.         if (CheckIO((struct IORequest *)SerialIO)) {
  274.             WaitIO((struct IORequest *) SerialIO);
  275.             if (!CheckIO((struct IORequest *) TimerIO) ) AbortIO((struct IORequest *) TimerIO);
  276.             WaitIO((struct IORequest *) TimerIO);
  277.             
  278. #ifdef comm_debug
  279.             printf("Received %d bytes:\n", SerialIO->IOSer.io_Actual);
  280.             print_bytes(cb, SerialIO->IOSer.io_Actual);
  281.             printf("\n");
  282. #endif
  283.             
  284.             if (SerialIO->IOSer.io_Actual!=max_size) {
  285.                 strcpy(error_msg, "Couldn't read enough");
  286.                 return;
  287.             }            
  288.             return;
  289.         }
  290.         
  291.         if (CheckIO((struct IORequest *) TimerIO) ){
  292.             // Timeout
  293.             WaitIO((struct IORequest *) TimerIO);
  294.             if (!CheckIO((struct IORequest *) SerialIO) )AbortIO((struct IORequest *) SerialIO);
  295.             WaitIO((struct IORequest *) SerialIO);
  296.             strcpy(error_msg, "timeout error");
  297.             return;
  298.         }
  299.          
  300.         if (result & (SIGBREAKF_CTRL_C|SIGBREAKF_CTRL_F)) {
  301.             if (!CheckIO((struct IORequest *) SerialIO) )AbortIO((struct IORequest *) SerialIO);
  302.             WaitIO((struct IORequest *) SerialIO);
  303.             if (!CheckIO((struct IORequest *) TimerIO) ) AbortIO((struct IORequest *) TimerIO);
  304.             WaitIO((struct IORequest *) TimerIO);
  305.             strcpy(error_msg, "User sent CTRL_C or F");
  306.             return;
  307.         }
  308.     }
  309. }
  310.  
  311. __inline void read_L1(L1 *v, char* error_msg) {
  312.     read(v, 1, error_msg);
  313. } 
  314.  
  315. __inline void read_L2(L2 *v, char* error_msg) {
  316.     read((L1 *) v, 2, error_msg);
  317.     *v=SetL2(*v);
  318. }
  319.  
  320. __inline void read_L4(L4 *v, char* error_msg) {
  321.     read((L1 *) v, 4, error_msg);
  322.     *v=SetL4(*v);
  323. }
  324.  
  325. __inline L2 checksum(L1 *start, L1 *end) {
  326.     L1 *i; L2 cs=0;
  327.     for (i=start; i<end; i++)
  328.         cs=cs+(L1) *i;
  329.  
  330.     return (L2) (cs &0xffff);
  331. }
  332.  
  333.  
  334. void SetIntegerRegister(enum Command_0 Register, L4 Value, char* error_msg) {
  335.     struct Command_0_Packet cmd;
  336.     L1 v; 
  337.     int retries;
  338.  
  339.     cmd.Packet_type=Packet_Command;
  340.     if (first_Packet) {
  341.         cmd.Packet_subtype=Packet_Subtype_First_Command;
  342.         first_Packet=0;
  343.     } else {
  344.         cmd.Packet_subtype=Packet_Subtype_Not_First_Command;
  345.     }
  346.     cmd.Length_of_data=SetL2(6);
  347.     cmd.Command_Code=0;
  348.     cmd.Register_Number=Register;
  349.     cmd.NewValue=SetL4(Value);
  350.     cmd.checksum=SetL2(checksum((L1 *) &(cmd.Command_Code), (L1 *) &(cmd.checksum)));
  351.  
  352. #ifdef debug
  353.     print_bytes((L1 *)&cmd, sizeof(struct Command_0_Packet));
  354. #endif
  355.  
  356.     retries=0;
  357.     while (retries<MAX_RETRIES) {
  358.         send((L1 *) &cmd, sizeof(struct Command_0_Packet), error_msg);
  359.         if (*error_msg!=0) return;
  360.         read_L1(&v, error_msg);
  361.         if (*error_msg!=0) return;
  362.         if (v==Camera_Positive_Achnowledgement) return;
  363.         else if (v==Camera_Unable_to_Execute_Command) retries++;
  364.         else {
  365. //            strcpy(error_msg, "Got unexpected data from camera");            // TetiSoft: No info
  366.             sprintf(error_msg, "Got unexpected data ($%08X) from camera", v);    // TetiSoft: More info
  367.             return;
  368.         }
  369.     }
  370. }
  371.  
  372.  
  373. void ReadIntegerRegister(enum Command_1 Register, L4 *value, char* error_msg) {
  374.     struct Command_1_Packet cmd;
  375.     L2 cs, ccs;
  376.     int retries=0;
  377.     L1 bb[10];
  378.     L4 *L4b;
  379.     
  380.     cmd.Packet_type=Packet_Command;
  381.     if (first_Packet) {
  382.         cmd.Packet_subtype=Packet_Subtype_First_Command;
  383.         first_Packet=0;
  384.     }
  385.     else {
  386.         cmd.Packet_subtype=Packet_Subtype_Not_First_Command;
  387.     }
  388.     
  389.     cmd.Length_of_data=0x0200;
  390.     cmd.Command_Code=0x01;
  391.     cmd.Register_Number=Register;
  392.     cmd.checksum=(Register+1)<<8;
  393.     
  394. #ifdef debug
  395.     print_bytes((L1 *) &cmd, sizeof(struct Command_1_Packet));
  396. #endif
  397.  
  398.     send((L1 *) &cmd, sizeof(struct Command_1_Packet), error_msg);
  399.     /* get packet */
  400.     while (retries<MAX_RETRIES) {
  401.         read(bb, 10, error_msg);
  402.         // check consistency;
  403.         
  404.         L4b=(L4 *) &bb[0];
  405.         if (*L4b!=0x03000400) {
  406. //            strcpy(error_msg, "Got unexpected data from camera");            // TetiSoft: No info
  407.             sprintf(error_msg, "Got unexpected data ($%08X) from camera", *L4b);    // TetiSoft: More info
  408.             return;
  409.         }
  410.         
  411.         *value= (L4) ((bb[7]<<24) + (bb[6]<<16) + (bb[5]<<8) + bb[4]);
  412.         cs=(L2) ((bb[9]<<8) + bb[8]);
  413.         ccs=(L4) (bb[4]+bb[5]+bb[6]+bb[7]);
  414.         if (cs!=ccs) {
  415.             printf("Checksum (=%x) is not calculated checksum (=%x)\n", cs, ccs);
  416.             retries++;
  417.             send_L1(Computer_Negative_Achnowledgement, error_msg);
  418.             if (*error_msg!=0) return;
  419.         } else {
  420.             send_L1(Computer_Positive_Achnowledgement, error_msg);
  421.             return; // return anyway
  422.         }
  423.     }
  424.     strcpy(error_msg, "Retry Error in ReadIntegerRegister()");
  425. }
  426.  
  427.  
  428. void TakeAction(enum Action_Code action, L1 arg, char* error_msg) {
  429.           /* struct and in this case struct Command_2_Packet has a special behavior.
  430.        When declaring an element, which takes more then one single byte
  431.        like L2 or L4, the structure will set the offset to an even number.
  432.        Example:
  433.  
  434.                 Offset:
  435.                         struct Command_2_Packet {
  436.                 0            L1 Packet_type;
  437.                 1            L1 Packet_subtype;
  438.                 2            L2 Length_of_data;
  439.  
  440.                 4            L1 Command_Code;
  441.                 5            L1 Action_Code;
  442.                 6            L1 single_byte;
  443.  
  444.                 8            L2 checksum;
  445.            }
  446.  
  447.              As You see, the offset 8 at checksum is an even address. So the
  448.       memory at offset 7 will not be used. 
  449.  
  450.       That is normaly no problem, as long as the structre is used in memory.
  451.       But in this case, the structre will be sent to the camera as a stream of
  452.       bytes. That means also the unused byte at offset 7 will be sent, which is
  453.       of course not part of the camera protocol. That's why I can't send it directly,
  454.              I have to send it in two parts (0..6 and 7..8).
  455.  
  456.              Why does the compiler this automatic offset changing? The reason is simple.
  457.       The 68000 family cpu (and mnay others too) can't access to odd addresses.
  458.       If You try, You will get an alert (=Guru message).
  459.     */
  460.  
  461.     struct Command_2_Packet cmd;
  462.     L1 bb[2]; L2 cs;
  463.  
  464.     cmd.Packet_type=Packet_Command;
  465.     if (first_Packet) {
  466.         cmd.Packet_subtype=Packet_Subtype_First_Command;
  467.         first_Packet=0;
  468.     } else {
  469.         cmd.Packet_subtype=Packet_Subtype_Not_First_Command;
  470.     }
  471.  
  472.     cmd.Length_of_data=0x0300;
  473.     cmd.Command_Code=0x02;
  474.     cmd.Action_Code=action;
  475.     if (action==AC_Set_Protection_State && arg!=0) cmd.single_byte=1;
  476.     else cmd.single_byte=0;
  477.     //cs=checksum((L1 *) &(cmd.Command_Code), (L1 *) (&(cmd.single_byte)+1));
  478.     cs=(2+action+cmd.single_byte);
  479.  
  480.     send((L1 *) &cmd, sizeof(struct Command_2_Packet)-3, error_msg);
  481.     if (*error_msg!=0) return;
  482.     send_L2(cs, error_msg);
  483.     if (*error_msg!=0) return;
  484.  
  485.     read(bb, 2, error_msg);
  486.     if (*error_msg!=0) return;
  487.     if (bb[0]!=Camera_Positive_Achnowledgement) {
  488.         strcpy(error_msg, "Error in TakeAction, no Camera ACK");
  489.         return;
  490.     }
  491.     if (bb[1]!=Camara_Action_Complete_Notification)
  492.         strcpy(error_msg, "Error in TakeAction, no action complete notification");
  493.     return;
  494. }
  495.  
  496.  
  497. void ReadVDataRegister(enum Command_4 Register, L1 *ret, L4 *total_size, char* error_msg) {
  498.     struct Command_4_Packet cmd;
  499.     L1 *bb, local_seq_number=0;
  500.     L2 size, cs, ccs;
  501.     int retry;
  502.     L1 minibuffer[4];
  503.     
  504.     bb=ret;
  505.     *total_size=0;
  506.     
  507.     cmd.Packet_type=Packet_Command;
  508.     if (first_Packet) {
  509.         cmd.Packet_subtype=Packet_Subtype_First_Command;
  510.         first_Packet=0;
  511.     }
  512.     else {
  513.         cmd.Packet_subtype=Packet_Subtype_Not_First_Command;
  514.     }
  515.     cmd.Length_of_data=0x0200;
  516.     cmd.Command_Code=4;
  517.     cmd.Register_Number=Register;
  518.     //cmd.checksum=SetL2(checksum((L1 *) &(cmd.Command_Code), (L1 *) &(cmd.checksum)));
  519.     cmd.checksum=(4+Register)<<8;
  520.  
  521.     send((L1 *) &cmd, sizeof(struct Command_4_Packet), error_msg);
  522.     if (*error_msg!=0) return;
  523.     
  524.     /* here, I should be able to receive one or many Data-Packages */
  525.     retry=0;
  526.     do {
  527.         read(minibuffer, 4, error_msg);
  528.         if (*error_msg!=0) return;
  529.         if (minibuffer[0]!=Packet_Last_in_Seq && minibuffer[0]!=Packet_Not_Last_in_Seq) {
  530.             strcpy(error_msg, "Got unexpected msg from camera in ReadVDataRegister()");
  531.             return;
  532.         }
  533.         
  534.         if (minibuffer[1]!=local_seq_number) {
  535.             strcpy(error_msg, "Packet seq doesn't match with internal seq");
  536.             return;
  537.         }
  538.  
  539.         size=(minibuffer[3]<<8) + minibuffer[2];
  540.         if (size>2048) {
  541.             strcpy(error_msg, "wrong size");
  542.             return;
  543.         }
  544.         if (retry==0) {
  545.             *total_size=*total_size+(L4) size;
  546.         }
  547.         read(bb, size+2, error_msg);
  548.         if (*error_msg!=0) return;
  549.         cs=(bb[size+1]<<8) + bb[size];
  550.         ccs=checksum((L1 *) bb, (L1 *) (bb+size));
  551.         if (cs!=ccs) {
  552.             printf("wrong checksum  (got=%x, calculated=%x)\n", cs, ccs);
  553.             retry++;
  554.         }
  555.         if (retry==0) {
  556.             /* send ACK */
  557.             send_L1(Computer_Positive_Achnowledgement, error_msg);
  558.             if (*error_msg!=0) return;
  559.             if (minibuffer[0]==Packet_Last_in_Seq) return;
  560.             bb+=size;
  561.             local_seq_number++;
  562.         
  563.         } else {
  564.             /* send NAK */
  565.             send_L1(Computer_Negative_Achnowledgement, error_msg);
  566.             if (*error_msg!=0) return;
  567.             retry=0;
  568.         }
  569.     } while (1);
  570. }
  571.  
  572. #ifdef comm_debug
  573.  
  574. void print_bytes(L1 *p, long len) {
  575.     long i, j, oldi;
  576.     
  577.     if (len<32) {
  578.         // print all
  579.         for (i=0;i<len;) {
  580.             oldi=i;
  581.             j=i+16;
  582.             if (j>len) j=len;
  583.             
  584.             for (;i<j;i++) {
  585.                 printf("%5d ", i);
  586.             }
  587.             printf("\n");
  588.             for (i=oldi;i<j;i++) {
  589.                 printf("%5x ", (int) p[i]);
  590.             }
  591.             printf("\n");
  592.         }
  593.         printf("\n\n");
  594.     } else {
  595.         // print two parts
  596.         
  597.         for (i=0;i<16;) {
  598.             oldi=i;
  599.             j=i+16;
  600.                         
  601.             for (;i<j;i++) {
  602.                 printf("%5d ", i);
  603.             }
  604.             printf("\n");
  605.             for (i=oldi;i<j;i++) {
  606.                 printf("%5x ", (int) p[i]);
  607.             }
  608.             printf("\n");
  609.         }
  610.         printf("\n");
  611.         
  612.         for (i=len-16;i<len;) {
  613.             oldi=i;
  614.             j=i+16;
  615.             if (j>len) j=len;
  616.             
  617.             for (;i<j;i++) {
  618.                 printf("%5d ", i);
  619.             }
  620.             printf("\n");
  621.             for (i=oldi;i<j;i++) {
  622.                 printf("%5x ", (int) p[i]);
  623.             }
  624.             printf("\n");
  625.         }
  626.         printf("\n\n");
  627.     }
  628. }
  629.  
  630. #endif
  631.  
  632. void save_Frame(int framenumber, char *name, char *comment, char* error_msg) {
  633.     BPTR file;
  634.     struct Command_4_Packet cmd;
  635.     L1 local_seq_number=0;
  636.     L2 size, cs, ccs;
  637.     int retry, not_all_read=1;
  638.     L1 minibuffer[4];
  639.     L1 buffer[2050];
  640.     
  641.     file=Open(name, MODE_NEWFILE);
  642.     if (file==NULL) {
  643.         strcpy(error_msg, "Couldn't open file");
  644.         return;
  645.     }
  646.     
  647.     SetIntegerRegister(Cmd_Set_Current_Frame_Number, (L1) framenumber, error_msg);
  648.     if (*error_msg!=0) {
  649.         Close(file);
  650.         DeleteFile(name);
  651.         return;
  652.     }
  653.     
  654.     // ask camera to send data
  655.  
  656.     cmd.Packet_type=Packet_Command;
  657.     if (first_Packet) {
  658.         cmd.Packet_subtype=Packet_Subtype_First_Command;
  659.         first_Packet=0;
  660.     }
  661.     else {
  662.         cmd.Packet_subtype=Packet_Subtype_Not_First_Command;
  663.     }
  664.     cmd.Length_of_data=0x0200;
  665.     cmd.Command_Code=4;
  666.     cmd.Register_Number=Cmd_Get_Current_Frame;
  667.     cmd.checksum=(4+Cmd_Get_Current_Frame)<<8;
  668.  
  669.     send((L1 *) &cmd, sizeof(struct Command_4_Packet), error_msg);
  670.     if (*error_msg!=0) {
  671.         printf("%s\n", error_msg);
  672.         Close(file);
  673.         DeleteFile(name);
  674.         strcpy(error_msg, "ReadVDRegister:Error during sending Packet");
  675.         return;
  676.     }
  677.  
  678.  
  679.     // read data and save them            
  680.     retry=0;
  681.     do {
  682.         // read a bit
  683.         read(minibuffer, 4, error_msg);
  684.         if (*error_msg!=0) {
  685.             Close(file);
  686.             DeleteFile(name);
  687.             return;
  688.         }
  689.  
  690.         if (minibuffer[0]!=Packet_Last_in_Seq && minibuffer[0]!=Packet_Not_Last_in_Seq) {
  691.             Close(file);
  692.             DeleteFile(name);
  693.             strcpy(error_msg, "Got unexpected msg from camera");
  694.             return;
  695.         }        
  696.         
  697.         if (minibuffer[1]!=local_seq_number) {
  698.             printf("Packet seq#=%d doesn't match with internal seq#%d\n", minibuffer[1], local_seq_number);
  699.             Close(file);
  700.             DeleteFile(name);
  701.             strcpy(error_msg, "Packet seq# doesn't match with internal seq#");
  702.             return;
  703.         }
  704.  
  705.         size=(minibuffer[3]<<8) + minibuffer[2];
  706.         if (size>2048) {
  707.             Close(file);
  708.             DeleteFile(name);
  709.             strcpy(error_msg, "wrong size (bigger then 2048");
  710.             return;
  711.         }
  712.         
  713.         read(buffer, size+2, error_msg);
  714.         if (*error_msg!=0) goto catch_save_Frame;
  715.         
  716.         cs=(buffer[size+1]<<8) + buffer[size];
  717.         ccs=checksum((L1 *) buffer, (L1 *) (buffer+size));
  718.         if (cs!=ccs) {
  719.             printf("wrong checksum  (got=%x, calculated=%x)\n", cs, ccs);
  720.             retry++;
  721.         }
  722.         if (retry==0) {
  723.             /* send ACK */
  724.             send_L1(Computer_Positive_Achnowledgement, error_msg);
  725.             if (*error_msg!=0) goto catch_save_Frame;
  726.             if (minibuffer[0]==Packet_Last_in_Seq) not_all_read=0;
  727.             local_seq_number++;
  728.         
  729.         } else {
  730.             /* send NAK */
  731.             send_L1(Computer_Negative_Achnowledgement, error_msg);
  732.             if (*error_msg!=0) goto catch_save_Frame;
  733.             retry=0;
  734.         }
  735.         goto skip_catch_save_Frame;
  736.     catch_save_Frame:
  737.         Close(file);
  738.         DeleteFile(name);
  739.         return;
  740.         
  741.     skip_catch_save_Frame:
  742.             
  743.         // save a bit    
  744.         if (-1==Write(file, (void *) buffer, size)) {
  745.             Close(file);
  746.             DeleteFile(name);
  747.             strcpy(error_msg, "Error during writing the file");
  748.             return;
  749.         }            
  750.     }
  751.     while (not_all_read!=0);
  752.     Close(file);
  753.     if (comment!=NULL) SetComment(name, comment);
  754.     return;
  755. }
  756.  
  757.  
  758. void save_Thumbnail(int framenumber, char *name, char *comment, char* error_msg) {
  759.  
  760.     long size=0;
  761.     long real_size=0;
  762.     L1* buffer;
  763.     BPTR file;
  764.     
  765.     Get_Length_of_Thumbnail(framenumber, &size, error_msg);
  766.     if (*error_msg!=0) return;
  767.     size=size+100; // to be sure
  768.     buffer=(L1 *)AllocMem(size, MEMF_CLEAR);
  769.     if (buffer==NULL) {
  770.         strcpy(error_msg, "not enough memory available");
  771.         return;
  772.     }
  773.     
  774.     file=Open(name, MODE_NEWFILE);
  775.     if (file==NULL) {
  776.         FreeMem(buffer, size);
  777.         strcpy(error_msg, "Couldn't open file");
  778.         return;
  779.     }
  780.         
  781.     SetIntegerRegister(Cmd_Set_Current_Frame_Number, (L1) framenumber, error_msg);
  782.     if (*error_msg!=0) {
  783.         Close(file);
  784.         DeleteFile(name);
  785.         FreeMem(buffer, size);
  786.         return;
  787.     }
  788.  
  789.     ReadVDataRegister(Cmd_Get_Current_Thumbnail, (L1 *) buffer, (L4 *) &real_size, error_msg);
  790.     if (*error_msg!=0) {
  791.         printf("%s\n", error_msg);
  792.         strcpy(error_msg, "An error occured in ReadVDataRegister(Cmd_Get_Current_Frame, (L1 *) buffer, size);\n");
  793.         Close(file);
  794.         DeleteFile(name);
  795.         FreeMem(buffer, size);
  796.         return;
  797.     }
  798.     if (-1==Write(file, (void *) buffer, real_size)) {
  799.         strcpy(error_msg, "Error during writing the file");
  800.         Close(file);
  801.         DeleteFile(name);
  802.         FreeMem(buffer, size);
  803.         return;
  804.     }
  805.     Close(file);
  806.     FreeMem(buffer, size);
  807.     if (comment!=NULL) SetComment(name, comment);
  808.     return;
  809. }
  810.  
  811.  
  812. void Set_Resolution(enum Resolution re, char* error_msg) {    // TetiSoft: Added enum
  813. //    int retries=0;    // TetiSoft: unused
  814.     MACRO_Set_Integer(Cmd_Set_Resolution, (L4) re, error_msg);
  815. }
  816.  
  817.  
  818. void Set_Clock(time_t c, char* error_msg) {
  819. //    int retries=0;    // TetiSoft: unused
  820.     MACRO_Set_Integer(Cmd_Set_Clock, (L4) c, error_msg);
  821. }
  822.  
  823.  
  824. void Set_Shutter_Speed(long ss, char* error_msg) {
  825. //    int retries=0;    // TetiSoft: unused
  826.     MACRO_Set_Integer(Cmd_Set_Shutter_Speed, (L4) ss, error_msg);
  827. }
  828.  
  829.  
  830. void Set_Aperture(enum Aperture a, char* error_msg) {
  831. //    int retries=0;    // TetiSoft: unused
  832.     MACRO_Set_Integer(Cmd_Set_Aperture, (L4) a, error_msg);
  833. }
  834.  
  835.  
  836. void Set_Color_Mode(enum Color_Mode cm, char* error_msg) {
  837. //    int retries=0;    // TetiSoft: unused
  838.     MACRO_Set_Integer(Cmd_Set_Color_Mode, (L4) cm, error_msg);
  839. }
  840.  
  841.  
  842. void Set_Flash_Mode(enum Flash_Mode fm, char* error_msg) {
  843. //    int retries=0;    // TetiSoft: unused
  844.     MACRO_Set_Integer(Cmd_Set_Flash_Mode, (L4) fm, error_msg);
  845. }
  846.  
  847.  
  848. void Set_Comm_Speed(enum Camera_Speed cs, char* error_msg) {
  849.     SetIntegerRegister(Cmd_Set_Comm_Speed, (L4) cs, error_msg);
  850.     if (*error_msg!=0) return;
  851.     Delay(5); // wait 0.5 seconds so camera can prepare for the change
  852.     SetSerialSpeed(cs, error_msg);
  853. }
  854.  
  855.  
  856. void Set_Bright_And_Contrast(enum Bright_Contrast bc, char* error_msg) {
  857. //    int retries=0;    // TetiSoft: unused
  858.     MACRO_Set_Integer(Cmd_Set_Bright_And_Contrast, (L4) bc, error_msg);
  859. }
  860.  
  861.  
  862. void Set_White_Balance(enum White_Balance wb, char* error_msg) {
  863. //    int retries=0;    // TetiSoft: unused
  864.     MACRO_Set_Integer(Cmd_Set_White_Balance, (L4) wb, error_msg);
  865. }
  866.  
  867.  
  868. void Set_Autoshut_on_Host_Timer(int aoht, char* error_msg) {
  869. //    int retries=0;    // TetiSoft: unused
  870.     MACRO_Set_Integer(Cmd_Set_Autoshut_on_Host_Timer, (L4) aoht, error_msg);
  871. }
  872.  
  873.  
  874. void Set_Autoshut_on_Field_Timer(int asoft, char* error_msg) {
  875. //    int retries=0;    // TetiSoft: unused
  876.     MACRO_Set_Integer(Cmd_Set_Autoshut_on_Field_Timer, (L4) asoft, error_msg);
  877. }
  878.  
  879.  
  880. void Set_LED(enum LED_Mode lm, char* error_msg) {
  881. //    int retries=0;    // TetiSoft: unused
  882.     MACRO_Set_Integer(Cmd_Set_LED, (L4) lm, error_msg);
  883. }
  884.  
  885.  
  886. void Set_Lens_Mode(enum Lens_Mode lm, char* error_msg) {
  887. //    int retries=0;    // TetiSoft: unused
  888.     MACRO_Set_Integer(Cmd_Set_Lens_Mode, (L4) lm, error_msg);
  889. }
  890.  
  891.  
  892. void Set_Date_Format(enum Date_Format df, char* error_msg) {
  893. //    int retries=0;    // TetiSoft: unused
  894.     MACRO_Set_Integer(Cmd_Set_Date_Format, (L4) df, error_msg);
  895. }
  896.  
  897.  
  898. void Set_Exp_Meter(enum Exp_Meter em, char* error_msg) {
  899. //    int retries=0;    // TetiSoft: unused
  900.     MACRO_Set_Integer(Cmd_Set_Exp_Meter, (L4) em, error_msg);
  901. }
  902.  
  903.  
  904. void Set_Optical_Mode(int AEL_WBL, int Fisheye, int Wide, int Digital_Zoom, int BAW, char* error_msg) {
  905.     L4 r=0;
  906. //    int retries=0;    // TetiSoft: unused
  907.     
  908.     if (AEL_WBL) r+=0x1;
  909.     if (Fisheye) r+=0x2;
  910.     if (Wide) r+=0x4;
  911.     if (Digital_Zoom) r+=0x8;
  912.     if (BAW) {r+=0x10;}    // TetiSoft: Added ;
  913.     
  914.     MACRO_Set_Integer(Cmd_Set_Optical_Mode, (L4) r, error_msg);
  915. }
  916.  
  917.  
  918. void Get_Resolution(enum Resolution *re, char* error_msg) {
  919.     L4 r;
  920. //    int retries=0;    // TetiSoft: unused
  921.     
  922.     MACRO_Get_FI_Integer(Cmd_Get_Resolution, error_msg);
  923.     if (*error_msg!=0) return;
  924.  
  925.     switch (r) {
  926.         case Standard_Resolution:
  927.         case High_Resolution:
  928.         case Extended_Resolution:
  929.             *re=(enum Resolution) r;    // TetiSoft: Added enum
  930.             return;
  931.         default:
  932.             *re=Unknown_Resolution;
  933.     }
  934. }
  935.  
  936.  
  937. void Get_Clock(time_t *c, char* error_msg) {
  938.     L4 r;
  939. //    int retries=0;    // TetiSoft: unused
  940.     
  941.     MACRO_Get_FI_Integer(Cmd_Get_Clock, error_msg);
  942.     *c=(time_t) r;
  943. }
  944.  
  945.  
  946. void Get_Shutter_Speed(long *ss, char* error_msg) {
  947.     L4 r;
  948. //    int retries=0;    // TetiSoft: unused
  949.     
  950.     MACRO_Get_FI_Integer(Cmd_Get_Shutter_Speed, error_msg);
  951.     *ss=(long) r;
  952. }
  953.  
  954.  
  955. void Get_Aperture(enum Aperture *a, char* error_msg) {
  956.     L4 r;
  957. //    int retries=0;    // TetiSoft: unused
  958.     
  959.     MACRO_Get_FI_Integer(Cmd_Get_Aperture, error_msg);
  960.  
  961.     switch (r) {
  962.         case Auto_Aperture:        // Added by TetiSoft
  963.         case Low_Aperture:
  964.         case Midium_Aperture:
  965.         case High_Aperture:
  966.             *a=(enum Aperture) r;    // TetiSoft: Added enum
  967.             break;
  968.         default:
  969.             *a=Unknown_Aperture;
  970.     }
  971. }
  972.  
  973.  
  974. void Get_Color_Mode(enum Color_Mode *cm, char* error_msg) {
  975.     L4 r;
  976. //    int retries=0;    // TetiSoft: unused
  977.     
  978.     MACRO_Get_FI_Integer(Cmd_Get_Color_Mode, error_msg);
  979.  
  980.     switch (r) {
  981.         case Color_Color_Mode:
  982.         case BAW_Color_Mode:
  983.             *cm=(enum Color_Mode) r;    // TetiSoft: Added enum
  984.             break;
  985.         default:
  986.             *cm=Unknown_Color_Mode;;
  987.     }
  988. }
  989.  
  990.  
  991. void Get_Flash_Mode(enum Flash_Mode *fm, char* error_msg) {
  992.     L4 r;
  993. //    int retries=0;    // TetiSoft: unused
  994.     
  995.     MACRO_Get_FI_Integer(Cmd_Get_Flash_Mode, error_msg);
  996.  
  997.     switch (r) {
  998.         case Auto_Flash_Mode:
  999.         case Force_Flash_Mode:
  1000.         case Off_Flash_Mode:
  1001.         case Anti_Red_Eye_Flash_Mode:
  1002.         case Slow_Sync_Flash_Mode:
  1003.             *fm=(enum Flash_Mode) r;    // TetiSoft: Added enum
  1004.             break;
  1005.             
  1006.         default:
  1007.             *fm=Unknown_Flash_Mode;
  1008.     }
  1009. }
  1010.  
  1011.  
  1012. void Get_Num_of_Frames_Taken(int *noft, char* error_msg) {
  1013.     L4 r;
  1014. //    int retries=0;    // TetiSoft: unused
  1015.     
  1016.     MACRO_Get_FI_Integer(Cmd_Get_Num_of_Frames_Taken, error_msg);
  1017.     *noft=(int) r;
  1018. }
  1019.  
  1020.  
  1021. void Get_Num_of_Frames_Left(int *nofl, char* error_msg) {
  1022.     L4 r;
  1023. //    int retries=0;    // TetiSoft: unused
  1024.     
  1025.     MACRO_Get_FI_Integer(Cmd_Get_Num_of_Frames_Left, error_msg);
  1026.     *nofl=(int) r;
  1027. }
  1028.  
  1029.  
  1030. void Get_Length_of_Frame(int framenumber, long *length, char* error_msg) {
  1031.     L4 r=0;        // TetiSoft: initialised
  1032. //    int retries=0;    // TetiSoft: unused
  1033.     get_preview=0;
  1034.     
  1035.     MACRO_Get_FD_Integer(framenumber, Cmd_Get_Length_of_Current_Frame, error_msg);
  1036.     *length=(long) r;
  1037. }
  1038.  
  1039.  
  1040. void Get_Length_of_Thumbnail(int framenumber, long *length, char* error_msg) {
  1041.     L4 r=0;        // TetiSoft: initialised
  1042. //    int retries=0;    // TetiSoft: unused
  1043.     get_preview=0;
  1044.     
  1045.     MACRO_Get_FD_Integer(framenumber, Cmd_Get_Length_of_Current_Thumbnail, error_msg);
  1046.     *length=(long) r;
  1047. }
  1048.  
  1049.  
  1050. void Get_Battery_Capacity(int *bc, char* error_msg) {
  1051.     L4 r=0;        // TetiSoft: initialised
  1052. //    int retries=0;    // TetiSoft: unused
  1053.     
  1054.     MACRO_Get_FI_Integer(Cmd_Get_Battery_Capacity, error_msg);
  1055.     *bc=(int) r;
  1056. }
  1057.  
  1058.  
  1059. void Get_Comm_Speed(enum Camera_Speed *cs, char* error_msg) {
  1060.     L4 r;
  1061. //    int retries=0;    // TetiSoft: unused
  1062.     
  1063.     MACRO_Get_FI_Integer(Cmd_Get_Comm_Speed, error_msg);
  1064.     r=r& 0xff;
  1065.     switch(r) {
  1066.         case CAMERA_SPEED_9600:
  1067.         case CAMERA_SPEED_19200:
  1068.         case CAMERA_SPEED_38400:
  1069.         case CAMERA_SPEED_57600:
  1070.         case CAMERA_SPEED_115200:
  1071.         case CAMERA_SPEED_230400:        // Added by TetiSoft
  1072.             *cs=(enum Camera_Speed) r;    // TetiSoft: Added enum
  1073.             break;
  1074.         default:
  1075.             *cs=CAMERA_SPEED_Unknown;
  1076.     }
  1077. }
  1078.  
  1079.  
  1080. void Get_Bright_And_Contrast(enum Bright_Contrast *bc, char* error_msg) {
  1081.     L4 r;
  1082. //    int retries=0;    // TetiSoft: unused
  1083.     
  1084.     MACRO_Get_FI_Integer(Cmd_Get_Bright_And_Contrast, error_msg);
  1085.  
  1086.     switch(r) {
  1087.         case Normal_Bright_Contrast:
  1088.         case More_Bright_Bright_Contrast:
  1089.         case Less_Bright_Bright_Contrast:
  1090.         case More_Contrast_Bright_Contrast:
  1091.         case Less_Contrast_Bright_Contrast:
  1092.             *bc=(enum Bright_Contrast) r;    // TetiSoft: Added enum
  1093.             break;
  1094.         
  1095.         default:
  1096.             *bc=Unknown_Bright_Contrast;
  1097.             break;
  1098.     }
  1099. }
  1100.  
  1101.  
  1102. void Get_White_Balance(enum White_Balance *wb, char* error_msg) {
  1103.     L4 r;
  1104. //    int retries=0;    // TetiSoft: unused
  1105.     
  1106.     MACRO_Get_FI_Integer(Cmd_Get_White_Balance, error_msg);
  1107.     
  1108.     switch(r) {
  1109.         case Auto_White_Balance:
  1110.         case Skylight_White_Balance:
  1111.         case Fluoresent_White_Balance:
  1112.         case Thungsten_White_Balance:
  1113.         case Cloudy_White_Balance:
  1114.             *wb=(enum White_Balance) r;    // TetiSoft: Added enum
  1115.             break;
  1116.         
  1117.         default:
  1118.             *wb=Unknown_White_Balance;
  1119.             break;
  1120.     }
  1121. }
  1122.  
  1123.  
  1124. void Get_Autoshut_on_Host_Timer(int *asoht, char* error_msg) {
  1125.     L4 r;
  1126. //    int retries=0;    // TetiSoft: unused
  1127.     
  1128.     MACRO_Get_FI_Integer(Cmd_Get_Autoshut_on_Field_Timer, error_msg);
  1129.     *asoht=(int) r;
  1130. }
  1131.  
  1132.  
  1133. void Get_Autoshut_on_Field_Timer(int *asoft, char* error_msg) {
  1134.     L4 r;
  1135. //    int retries=0;    // TetiSoft: unused
  1136.     
  1137.     MACRO_Get_FI_Integer(Cmd_Get_Autoshut_on_Field_Timer, error_msg);
  1138.     *asoft=(int) r;
  1139. }
  1140.  
  1141.  
  1142. void Get_Available_Memory_Left(long *aml, char* error_msg) {
  1143.     L4 r;
  1144. //    int retries=0;    // TetiSoft: unused
  1145.     
  1146.     MACRO_Get_FI_Integer(Cmd_Get_Available_Memory_Left, error_msg);
  1147.     *aml=(int) r;
  1148. }
  1149.  
  1150.  
  1151. void Get_Lens_Mode(enum Lens_Mode *lm, char* error_msg) {
  1152.     L4 r;
  1153. //    int retries=0;    // TetiSoft: unused
  1154.  
  1155.     MACRO_Get_FI_Integer(Cmd_Get_Lens_Mode, error_msg);
  1156.  
  1157.     switch(r) {
  1158.         case Macro_Lens_Mode:
  1159.         case Normal_Lens_Mode:
  1160.         case Infinity_Fisheye_Lens_Mode:
  1161.             *lm=(enum Lens_Mode) r;    // TetiSoft: Added enum
  1162.             break;
  1163.         
  1164.         default:
  1165.             *lm=Unknown_Lens_Mode;
  1166.             break;
  1167.     }
  1168. }
  1169.  
  1170. void Get_LCD_Brightness(int *lb, char* error_msg) {
  1171.     L4 r;
  1172. //    int retries=0;    // TetiSoft: unused
  1173.     
  1174.     MACRO_Get_FI_Integer(Cmd_Get_LCD_Brightness, error_msg);
  1175.     *lb=(int) r;
  1176. }
  1177.  
  1178.  
  1179. void Get_LCD_Autoshut_Timer(int *lat, char* error_msg) {
  1180.     L4 r;
  1181. //    int retries=0;    // TetiSoft: unused
  1182.     
  1183.     MACRO_Get_FI_Integer(Cmd_Get_LCD_Autoshut_Timer, error_msg);
  1184.     *lat=(int) r;
  1185. }
  1186.  
  1187.  
  1188. void Get_Protect_State_of_Frame(int framenumber, int *psof, char* error_msg) {
  1189.     L4 r=0;        // TetiSoft: initialised
  1190. //    int retries=0;    // TetiSoft: unused
  1191.     get_preview=0;
  1192.     
  1193.     MACRO_Get_FD_Integer(framenumber, Cmd_Get_Protect_State_of_Current_Frame, error_msg);
  1194.     *psof=(int) r;
  1195. }
  1196.  
  1197.  
  1198. void Get_Date_Format(enum Date_Format *df, char* error_msg) {
  1199.     L4 r;
  1200. //    int retries=0;    // TetiSoft: unused
  1201.     
  1202.     MACRO_Get_FI_Integer(Cmd_Get_Date_Format, error_msg);
  1203.  
  1204.     switch(r) {
  1205.         case YY_MM_DD_Date_Format:
  1206.         case DD_MM_HH_Date_Format:
  1207.         case DD_P_MM_P_Date_Format:        // Added by TetiSoft
  1208.             *df=(enum Date_Format) r;    // TetiSoft: Added enum
  1209.             break;
  1210.         
  1211.         default:
  1212.             *df=Unknown_Date_Format;
  1213.             break;
  1214.     }
  1215. }
  1216.  
  1217.  
  1218. void Get_Exp_Meter(enum Exp_Meter *em, char* error_msg) {
  1219.     L4 r;
  1220. //    int retries=0;    // TetiSoft: unused
  1221.     
  1222.     MACRO_Get_FI_Integer(Cmd_Get_Exp_Meter, error_msg);
  1223.  
  1224.     switch(r) {
  1225.         case Center_weighted_Exp_Meter:
  1226.         case Spot_Exp_Meter:
  1227.         case Multi_Element_Matrix_Exp_Meter:
  1228.             *em=(enum Exp_Meter) r;    // TetiSoft: Added enum
  1229.             break;
  1230.         
  1231.         default:
  1232.             *em=Unknown_Exp_Meter;
  1233.             break;
  1234.     }
  1235. }
  1236.  
  1237.  
  1238. void Get_Optical_Mode(int *AEL_WBL, int *Fisheye, int *Wide, int *Digital_Zoom, int *BAW, char* error_msg) {
  1239.     L4 r;
  1240. //    int retries=0;    // TetiSoft: unused
  1241.     
  1242.     MACRO_Get_FI_Integer(Cmd_Get_Optical_Mode, error_msg);
  1243.     
  1244.     *AEL_WBL=(r & 0x1);
  1245.     *Fisheye=(r & 0x2);
  1246.     *Wide=(r & 0x4);
  1247.     *Digital_Zoom=(r & 0x8);
  1248.     *BAW=(r & 0x10);
  1249. }
  1250.  
  1251.  
  1252. void Get_Frame(int framenumber, UBYTE *buffer, long *size, char* error_msg) {
  1253. //    int retries=0;    // TetiSoft: unused
  1254.     get_preview=0;
  1255.     
  1256.     MACRO_Get_FD_VData(framenumber, Cmd_Get_Current_Frame, buffer, size, error_msg);
  1257. }
  1258.  
  1259.  
  1260. void Get_Thumbnail(int framenumber, UBYTE *buffer, long *size, char* error_msg)  {
  1261. //    int retries=0;    // TetiSoft: unused
  1262.     get_preview=0;
  1263.     
  1264.     MACRO_Get_FD_VData(framenumber, Cmd_Get_Current_Thumbnail, buffer, size, error_msg);
  1265. }
  1266.  
  1267.  
  1268. void Get_Camera_ID(UBYTE *buffer, long *size, char* error_msg) {
  1269. //    int retries=0;    // TetiSoft: unused
  1270.         
  1271.     MACRO_Get_FI_VData(Cmd_Get_Camera_ID, buffer, size, error_msg);
  1272. }
  1273.  
  1274.  
  1275. void Get_Serial_Number(UBYTE *buffer, long *size, char* error_msg) {
  1276. //    int retries=0;    // TetiSoft: unused
  1277.     
  1278.     MACRO_Get_FI_VData(Cmd_Get_Serial_Number, buffer, size, error_msg);
  1279. }
  1280.  
  1281.  
  1282. void Get_Version(UBYTE *buffer, long *size, char* error_msg) {
  1283. //    int retries=0;    // TetiSoft: unused
  1284.     
  1285.     MACRO_Get_FI_VData(Cmd_Get_Version, buffer, size, error_msg);
  1286. }
  1287.  
  1288.  
  1289. void Get_Model(char *string, long *size, char* error_msg) {
  1290. //    int retries=0;    // TetiSoft: unused
  1291.     
  1292.     MACRO_Get_FI_VData(Cmd_Get_Model, string, size, error_msg);
  1293. }
  1294.  
  1295.  
  1296. /* not supported by many cameras */
  1297. void Get_Audio_Data(UBYTE *buffer, long *size, char* error_msg) {
  1298. //    int retries=0;    // TetiSoft: unused
  1299.  
  1300.     MACRO_Get_FI_VData(Cmd_Get_Audio_Data, buffer, size, error_msg);
  1301. }
  1302.  
  1303.  
  1304. void Get_Camera_Summery_Data(enum Resolution *re, int *LCD_Brightness, int *Frames_Taken, char* error_msg) {
  1305. //    int retries=0;        // TetiSoft: unused
  1306.     L4 buffer[1024];    // TetiSoft: Increased buffer (was 8)
  1307.     long sizeVal;        // Added by TetiSoft
  1308.     long *size=&sizeVal;    // TetiSoft: Fixed NULL init
  1309.         
  1310.     MACRO_Get_FI_VData(Cmd_Get_Camera_Summery_Data, buffer, size, error_msg);
  1311.  
  1312.     *re=(enum Resolution)SetL4(buffer[0]);    // TetiSoft: Added enum
  1313.     *LCD_Brightness=(int)SetL4(buffer[1]);
  1314.     *Frames_Taken=(int) SetL4(buffer[2]);
  1315. }
  1316.  
  1317.  
  1318. void Get_Picture_Summery_Data(int framenumber, long *AudioDataLength, enum Resolution *re, int *ProtectionState, time_t *TimeDate, char* error_msg) {
  1319. //    int retries=0;        // TetiSoft: unused
  1320.     L4 buffer[1024]={0};    // TetiSoft: Increased buffer (was 8), initialised it
  1321.     long sizeVal=0;        // Added by TetiSoft
  1322.     long *size=&sizeVal;    // TetiSoft: Fixed NULL init
  1323.     get_preview=0;
  1324.     
  1325.     MACRO_Get_FD_VData(framenumber, Cmd_Get_Picture_Summery_Data, buffer, size, error_msg);
  1326.     if (*error_msg!=0) return;
  1327.  
  1328.     if ((*size)<20) {
  1329.         strcpy(error_msg, "wrong size of data packet");
  1330.         return;
  1331.     }
  1332.     *AudioDataLength=(long)SetL4(buffer[2]);
  1333.  
  1334.     switch(SetL4(buffer[3])) {
  1335.         case Standard_Resolution:
  1336.         case High_Resolution:
  1337.         case Extended_Resolution:
  1338.             *re=(enum Resolution)SetL4(buffer[3]);    // TetiSoft: Added enum
  1339.             break;
  1340.     
  1341.         default:
  1342.             *re=Unknown_Resolution;
  1343.             break;
  1344.     }
  1345.  
  1346.     *ProtectionState=(int) SetL4(buffer[4]);
  1347.     *TimeDate=(time_t) SetL4(buffer[5]);
  1348.  
  1349. }
  1350.  
  1351.  
  1352. void Get_Manufacturer(char *string, long *size, char* error_msg) {
  1353. //    int retries=0;    // TetiSoft: unused
  1354.     
  1355.     MACRO_Get_FI_VData(Cmd_Get_Manufacturer, string, size, error_msg);
  1356. }
  1357.  
  1358.  
  1359. void Get_Preview(UBYTE *buffer, long *size, char* error_msg)  {
  1360.     
  1361.     
  1362.     TakeAction(AC_Take_Preview_Snapshot, 0, error_msg);
  1363.     if (*error_msg!=0) {
  1364.         printf("%s\n", error_msg);
  1365.         strcpy(error_msg, "An error occured in TakeAction(AC_Take_Preview_Snapshot, 0);");
  1366.         return;
  1367.     }
  1368.     
  1369.     if (get_preview==0) {
  1370.     
  1371.         SetIntegerRegister(Cmd_Set_Current_Frame_Number, (L1) 0, error_msg);
  1372.         if (*error_msg!=0) {
  1373.             printf("%s\n", error_msg);
  1374.             strcpy(error_msg, "An error occured in SetIntegerRegister(Cmd_Set_Current_Frame_Number, (L1) 0);");
  1375.             return;
  1376.         }
  1377.     }
  1378.     
  1379.     get_preview=1;
  1380.     
  1381.     ReadVDataRegister(Cmd_Get_Current_Frame, (L1 *) buffer, (L4 *) size, error_msg);
  1382.     if (*error_msg!=0) {
  1383.         printf("%s\n", error_msg);
  1384.         strcpy(error_msg, "An error occured in ReadVDataRegister(Cmd_Get_Current_Frame, (L1 *) buffer, size);\n");
  1385.     }
  1386.     return;
  1387. }
  1388.  
  1389.  
  1390. char* dump_Resolution(enum Resolution r) {
  1391.     switch (r) {
  1392.         case Standard_Resolution:
  1393.             return "Standard";
  1394.         
  1395.         case High_Resolution:
  1396.             return "High";
  1397.         
  1398.         case Extended_Resolution:
  1399.             return "Extended";
  1400.         
  1401.         default:
  1402.             return "Unknown";
  1403.     }
  1404. }
  1405.  
  1406.  
  1407. char* dump_Aperture(enum Aperture a) {
  1408.     switch(a) {
  1409.         case Auto_Aperture:    // Added by TetiSoft
  1410.             return "Auto";    // Added by TetiSoft
  1411.  
  1412.         case Low_Aperture:
  1413.             return "Low";
  1414.         
  1415.         case Midium_Aperture:
  1416.             return "Midium";
  1417.         
  1418.         case High_Aperture:
  1419.             return "High";
  1420.         
  1421.         default:
  1422.             return "Unknown";
  1423.     }
  1424. }
  1425.  
  1426.  
  1427. char* dump_Color_Mode(enum Color_Mode cm) {
  1428.     switch(cm) {
  1429.         case Color_Color_Mode:
  1430.             return "Color";
  1431.         
  1432.         case BAW_Color_Mode:
  1433.             return "B&W";
  1434.         
  1435.         default:
  1436.             return "Unknown";
  1437.     }
  1438. }
  1439.  
  1440.  
  1441. char* dump_Flash_Mode(enum Flash_Mode fm) {
  1442.     switch(fm) {
  1443.         case Auto_Flash_Mode:
  1444.             return "Auto";
  1445.         
  1446.         case Force_Flash_Mode:
  1447.             return "Force";
  1448.             
  1449.         case Off_Flash_Mode:
  1450.             return "Off";
  1451.         
  1452.         case Anti_Red_Eye_Flash_Mode:
  1453.             return "Anti_Red_Eye";
  1454.         
  1455.         case Slow_Sync_Flash_Mode:
  1456.             return "Slow_Sync";
  1457.             
  1458.         default:
  1459.             return "Unknown";
  1460.     }
  1461. }    
  1462.  
  1463.  
  1464. char* dump_Camera_Speed(enum Camera_Speed cs) {
  1465.     switch (cs) {
  1466.         case CAMERA_SPEED_INIT:
  1467.             return "init-speed (=19200)";
  1468.         
  1469.         case CAMERA_SPEED_9600:
  1470.             return "9600";
  1471.             
  1472.         case CAMERA_SPEED_19200:
  1473.             return "19200";
  1474.         
  1475.         case CAMERA_SPEED_38400:
  1476.             return "38400";
  1477.         
  1478.         case CAMERA_SPEED_57600:
  1479.             return "57600";
  1480.         
  1481.         case CAMERA_SPEED_115200:
  1482.             return "115200";
  1483.             
  1484.         case CAMERA_SPEED_230400:    // Added by TetiSoft
  1485.             return "230400";    // Added by TetiSoft
  1486.             
  1487.         default:
  1488.             return "Unknown";
  1489.     }
  1490. }
  1491.  
  1492.  
  1493. char* dump_Bright_Contrast(enum Bright_Contrast bc) {
  1494.     switch (bc) {
  1495.         case Normal_Bright_Contrast:
  1496.             return "Normal_Bright";
  1497.         
  1498.         case More_Bright_Bright_Contrast:
  1499.             return "More_Bright";
  1500.         
  1501.         case Less_Bright_Bright_Contrast:
  1502.             return "Less_Bright";
  1503.             
  1504.         case More_Contrast_Bright_Contrast:
  1505.             return "More_Contrast";
  1506.         
  1507.         case Less_Contrast_Bright_Contrast:
  1508.             return "Less_Contrast";
  1509.             
  1510.         default:
  1511.             return "Unknown";
  1512.     }
  1513. }
  1514.  
  1515.  
  1516. char* dump_White_Balance(enum White_Balance wb) {
  1517.     switch (wb) {
  1518.         case Auto_White_Balance:
  1519.             return "Auto";
  1520.         
  1521.         case Skylight_White_Balance:
  1522.             return "Skylight";
  1523.         
  1524.         case Fluoresent_White_Balance:
  1525.             return "Fluoresent";
  1526.         
  1527.         case Thungsten_White_Balance:
  1528.             return "Thungsten";
  1529.         
  1530.         case Cloudy_White_Balance:
  1531.             return "Cloudy";
  1532.         
  1533.         default:
  1534.             return "Unknown";
  1535.     }
  1536. }
  1537.  
  1538.  
  1539. char* dump_Lens_Mode(enum Lens_Mode lm) {
  1540.     switch (lm) {
  1541.         case Macro_Lens_Mode:
  1542.             return "Macro";
  1543.         
  1544.         case Normal_Lens_Mode:
  1545.             return "Normal";
  1546.         
  1547.         case Infinity_Fisheye_Lens_Mode:
  1548.             return "Infinity_Fisheye";
  1549.         
  1550.         default:
  1551.             return "Unknown";
  1552.     }
  1553. }
  1554.  
  1555.  
  1556. char* dump_Date_Format(enum Date_Format df) {
  1557.     switch (df) {
  1558.         case YY_MM_DD_Date_Format:
  1559.             return "YY MM DD";
  1560.  
  1561.         case DD_MM_HH_Date_Format:
  1562.             return "DD MM HH";
  1563.  
  1564.         case DD_P_MM_P_Date_Format:    // Added by TetiSoft
  1565.             return "D. M. 'YY";    // Added by TetiSoft
  1566.         
  1567.         default:
  1568.             return "Unknown";
  1569.     }
  1570. }
  1571.  
  1572.  
  1573. char* dump_Exp_Meter(enum Exp_Meter em) {
  1574.     switch (em) {
  1575.         case Center_weighted_Exp_Meter:
  1576.             return "Center_weighted";
  1577.         
  1578.         case Spot_Exp_Meter:
  1579.             return "Spot";
  1580.         
  1581.         case Multi_Element_Matrix_Exp_Meter:
  1582.             return "Multi_Element_Matrix";
  1583.         
  1584.         default:
  1585.             return "Unknown";
  1586.     }
  1587. }
  1588.  
  1589.  
  1590. char* dump_LED_Mode(enum LED_Mode lm) {
  1591.     switch (lm) {
  1592.         case Off_LED_Mode:
  1593.             return "Off";
  1594.         
  1595.         case On_LED_Mode:
  1596.             return "On";
  1597.         
  1598.         case Blink_LED_Mode:
  1599.             return "Blink";
  1600.         
  1601.         default:
  1602.             return "Unknown";
  1603.     }
  1604. }
  1605.